using System;
using System.Collections;
using System.Diagnostics;
using System.Drawing;
//using System.Linq;
using System.IO;
//using System.Xml.Linq;
using System.Windows.Forms;
using Infragistics.Win.UltraWinGrid;
//using System.Configuration.ConfigurationManager;....
//using clsVariables;
//'

namespace Utiles
{
    //'
    public class Errores
    {

        public static void LogGrabar(string strProcedimiento, Exception exX, string strMjeLog, string strTextoDirecto)
        {
            //If Not String.IsNullOrEmpty(str_FicheroLog) Then
            StreamWriter sw = new StreamWriter(clsVariables.str_FicheroLog, true);
            string strMje = string.Empty;
            //'
            try
            {
                strMje = DateTime.Now.ToString("dd/MM/yyyy hh:mm:ss") + "- ";
                if (!string.IsNullOrEmpty(strTextoDirecto))
                {
                    strMje += strTextoDirecto;
                }
                else if (!string.IsNullOrEmpty(strMjeLog))
                {
                    strMje += String.Format("Procedimiento: {0}{1}Error: {2}", strProcedimiento, Environment.NewLine, strMjeLog);
                    strMje += string.Empty.PadLeft(20, '-') + Environment.NewLine + Environment.NewLine;
                }
                else if (!(exX == null))
                {
                    strMje += ExceptionToString(exX, strProcedimiento);
                    strMje += string.Empty.PadLeft(20, '-') + Environment.NewLine + Environment.NewLine;
                }
                //
                sw.WriteLine(strMje);
                sw.Close();
            }
            catch (Exception ex)
            {
                sw = null;
                LanzarError(null, "LogGRabar", "", ex, MessageBoxIcon.Exclamation, true); //Errores.Errores.AgregarToLog()
            }
            finally
            {
                sw.Dispose();
            }
            //End If
        }
        /// <summary>
        /// Error ampliado
        /// Muestra 3 líneas. 1a el MensajeError. 2a el ExceptionActual.message y 3a el ExceptionActual.StackTrace
        /// Si no viene ExceptionActual ni mensaje no muestra nada (Por ejemplo usando throw new exception (""))
        /// </summary>
        /// <param name="oForm">Form para poner el cursor en default</param>
        /// <param name="strFuncion">Función que puede dar error</param>
        /// <remarks></remarks>
        public static void LanzarError(Form oForm, string strFuncion, string strMensajeError, Exception ExceptionActual, MessageBoxIcon TipoMensaje, bool bolGRabarLog = false)
        {
            if (oForm != null)
            {
                oForm.Cursor = Cursors.Default;
            }
            //
            if (!string.IsNullOrEmpty(strMensajeError) && ExceptionActual == null) //Viene mensaje y no error
            {
                strMensajeError = String.Format("Error en {0}{1}{2}{1}{3}", strFuncion, Environment.NewLine, string.Empty.PadLeft(20, '-'), strMensajeError);
                //
            }
            else if (string.IsNullOrEmpty(strMensajeError) && ExceptionActual != null) //Viene error y no mensaje
            {
                strMensajeError += ExceptionToString(ExceptionActual, strFuncion);
                //
            }
            else if (!string.IsNullOrEmpty(strMensajeError) && ExceptionActual != null) //Viene mensaje y error
            {
                strMensajeError = strMensajeError + Environment.NewLine + Environment.NewLine + ExceptionToString(ExceptionActual, strFuncion);
            }
            //
            {
                //MsgBox(strMensajeError, MsgBoxStyle.Critical, IIf(TipoMensaje = MsgBoxStyle.Exclamation, "Error", "Atención"))
                MessageBox.Show(strMensajeError, TipoMensaje == MessageBoxIcon.Error ? "Error" : "Atención", MessageBoxButtons.OK, TipoMensaje);
            }
            if (bolGRabarLog)
            {
                LogGrabar(strFuncion, null, "", strMensajeError);
            }
            //'
        }
        //'
        /// <summary>
        /// Desarrollar una Exception, mostrandola como string.
        /// </summary>
        /// <param name="e"></param>
        /// <param name="strProcedimiento"></param>
        /// <returns></returns>
        /// <remarks></remarks>
        public static string ExceptionToString(Exception e, string strProcedimiento)
        {
            string cMsgErr = "";
            cMsgErr += "Se ha producido un error. Info: " + Environment.NewLine;
            if (strProcedimiento != "")
            {
                cMsgErr += String.Format("@Procedimiento:    {0}{1}", strProcedimiento, Environment.NewLine);
            }
            cMsgErr += String.Format("@Mensaje:       {0}{1}", e.Message, Environment.NewLine);
            cMsgErr += String.Format("@Assembly:      {0}{1}", e.Source, Environment.NewLine);
            cMsgErr += String.Format("@StackTrace:    {0}{1}", e.StackTrace, Environment.NewLine);
            cMsgErr += String.Format("@HelpLink:      {0}{1}", e.HelpLink, Environment.NewLine);
            if (e.TargetSite != null)
            {
                cMsgErr += "@TargetSite:    " + e.TargetSite.ToString();
            }
            if (e.InnerException == null)
            {
                cMsgErr += Environment.NewLine;
                cMsgErr += String.Format("______________________________________________________________{0}", Environment.NewLine);
                cMsgErr += String.Format("MachineName:        {0}{1}", General.ObtenerGetMachineName(), Environment.NewLine);
                cMsgErr += String.Format("TimeStamp:          {0}{1}", DateTime.Now, Environment.NewLine);
                cMsgErr += String.Format("FullName:           {0}{1}", System.Reflection.Assembly.GetExecutingAssembly().FullName, Environment.NewLine);
                cMsgErr += String.Format("AppDomainName:      {0}{1}", AppDomain.CurrentDomain.FriendlyName, Environment.NewLine);
                cMsgErr += String.Format("ThreadIdentity:     {0}{1}", System.Threading.Thread.CurrentPrincipal.Identity.Name, Environment.NewLine);
                cMsgErr += String.Format("WindowsIdentity:    {0}{1}", General.ObtenerGetWindowsIdentity(), Environment.NewLine);
            }
            return cMsgErr;
        }
    }
    //'
    public class UtilControlesNET
    {
        //// Import GetFocus() from user32.dll
        //[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.Winapi)]
        //internal static extern IntPtr GetFocus();
        ///// <summary>
        ///// Obtiene el foco del control actual 
        ///// </summary>
        ///// <returns></returns>
        //public static Control GetFocusControl()
        //{
        //    Control focusControl = null;
        //    IntPtr focusHandle = GetFocus();
        //    if (focusHandle != IntPtr.Zero)
        //        // returns null if handle is not to a .NET control
        //        focusControl = Control.FromHandle(focusHandle);
        //    return focusControl;
        //} 
        //'
        /// <summary>
        /// Pasas nombre control (string) y devuelve instacia del mismo
        /// </summary>
        /// <remarks></remarks>
        public static Control ObtenerControlPorNombre(string NombreControl, Form FormActivo)
        {
            System.Reflection.FieldInfo Info = FormActivo.GetType().GetField(String.Format("_{0}", NombreControl),
               System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.IgnoreCase);

            if (Info == null)
            {
                return null;
            }
            else
            {
                return ((Control)(Info.GetValue(FormActivo)));
            }
        }
        //'
        public static void ActivarAutocompletarCombo(ComboBox cbx)
        {
            ComboBox with_1 = cbx;
            with_1.DropDownStyle = ComboBoxStyle.DropDown;
            with_1.AutoCompleteSource = AutoCompleteSource.ListItems;
            with_1.AutoCompleteMode = AutoCompleteMode.Append;
        }
    }
    //'
    public class UtilInfragistics
    {

        //'
        //Public Class Ctrl_UltraTabControl
        //   ''' <summary>
        //   ''' Define colores estandar Ageinfo para el control Tab
        //   ''' </summary>
        //   ''' <param name="TabTratado"></param>
        //   ''' <remarks></remarks>
        //   Public Shared Sub EstandarFormatoTabAgeinfo(ByRef TabTratado As Infragistics.Win.UltraWinTabControl.UltraTabControl)
        //      For Each tb As Infragistics.Win.UltraWinTabControl.UltraTab In TabTratado.Tabs
        //         With tb
        //            .Appearance.ForeColor = System.Drawing.SystemColors.Highlight
        //            .Appearance.BackColor = System.Drawing.Color.FromName(Configuracion.Entorno.AGeObtenerAppSettings(Configuracion.Entorno.Prefijo, "ColorBarra"))
        //            .Appearance.ThemedElementAlpha = Infragistics.Win.Alpha.Transparent
        //            '.ActiveAppearance.BackColor = System.Drawing.SystemColors.ActiveCaption
        //            .Appearance.FontData.Bold = Infragistics.Win.DefaultableBoolean.True
        //            .ActiveAppearance.BackColor = System.Drawing.Color.FromName(Configuracion.Entorno.AGeObtenerAppSettings(Configuracion.Entorno.Prefijo, "ColorBarra"))
        //            .ActiveAppearance.ForeColor = System.Drawing.SystemColors.HighlightText
        //            .ActiveAppearance.ThemedElementAlpha = Infragistics.Win.Alpha.Transparent
        //         End With
        //      Next
        //   End Sub
        //End Class
        //'
        public class Ctrl_UltraToolbarsManager
        {

            /// <summary>
            /// Además colorea ....
            /// </summary>
            /// <param name="utmAFormatear"></param>
            /// <remarks></remarks>
            public static void ScpEstandarBarra(ref Infragistics.Win.UltraWinToolbars.UltraToolbarsManager utmAFormatear)
            {
                Infragistics.Win.UltraWinToolbars.UltraToolbar UltraToolbar1 = utmAFormatear.Toolbars[0];

                utmAFormatear.AlwaysShowMenusExpanded = Infragistics.Win.DefaultableBoolean.True;
                utmAFormatear.UseLargeImagesOnMenu = true;
                utmAFormatear.UseLargeImagesOnToolbar = true;
                //
                utmAFormatear.DesignerFlags = 1;
                utmAFormatear.LockToolbars = true;
                utmAFormatear.MdiMergeable = false;
                utmAFormatear.MenuAnimationStyle = Infragistics.Win.UltraWinToolbars.MenuAnimationStyle.Slide;
                utmAFormatear.ShowFullMenusDelay = 500;
                utmAFormatear.ShowQuickCustomizeButton = false;
                utmAFormatear.ShowShortcutsInToolTips = true;
                utmAFormatear.Style = Infragistics.Win.UltraWinToolbars.ToolbarStyle.Office2003;

                UltraToolbar1.DockedColumn = 0;
                UltraToolbar1.DockedRow = 0;
                UltraToolbar1.Settings.FillEntireRow = Infragistics.Win.DefaultableBoolean.True;

                clsControlColores.CambiarColorBarra(utmAFormatear);
            }
        }
        //'
        public class Ctrl_UltraGrid
        {
            //'
            #region Exportar grid a Excel
            public enum eIdioma
            {
                Espanyol,
                Catalan
            }
            /// <summary>
            /// Exporta de un grid a una hoja Excel
            /// Si el grid tiene filtros propios de infragistics tb los agrega
            /// </summary>
            /// <param name="gridaExportar"></param>
            /// <param name="RutaExcelConNombreYExtension">Ej: "E:\Personal\TaskManager\prueba.xls"</param>
            /// <param name="bolAbrirDespuesDeCrear">Nadamás crear el Excel lo abre o no?</param>
            /// <param name="Idioma ">Idioma del SaveDialog del Excel</param>
            /// <param name="lFiltros ">Orden a agregar al ya establecido por el grid</param>
            /// <remarks></remarks>
            public static void ExportGridToExcel(UltraGrid gridaExportar, string RutaExcelConNombreYExtension, bool bolAbrirDespuesDeCrear, eIdioma Idioma, bool bolMostrarMensajeFinalizado, System.Collections.Generic.List<string> lFiltros)
            {
                SaveFileDialog sfdExcel;
                //string DirectorioGuardadoExcel = string.Empty;
                Infragistics.Win.UltraWinGrid.ExcelExport.UltraGridExcelExporter ugExcelExporter = null;
                Infragistics.Documents.Excel.Workbook bookXls = null;
                System.Collections.Generic.List<string> ListaFiltros;
                System.Collections.Specialized.StringCollection scMensajes = new System.Collections.Specialized.StringCollection();

                try
                {
                    //Comprobar lenguaje
                    switch (Idioma)
                    {
                        case eIdioma.Espanyol:
                            scMensajes.Add("Grabar Archivo Excel");

                            scMensajes.Add("Proceso finalizado");
                            scMensajes.Add("Realizado");
                            break;
                        case eIdioma.Catalan:
                            scMensajes.Add("Grabar Archiu Excel");

                            scMensajes.Add("");
                            scMensajes.Add("Realitzat");
                            break;
                    }

                    //Sino incluimos ruta cargar para escoger destino
                    if (String.IsNullOrEmpty(RutaExcelConNombreYExtension) || Directory.Exists(Path.GetDirectoryName(RutaExcelConNombreYExtension)) == false)
                    {
                        sfdExcel = new SaveFileDialog();
                        sfdExcel.Filter = Idioma == eIdioma.Espanyol ? "XLS Archivo Excel|*.xls" : "XLS Archiu Excel|*.xls";
                        sfdExcel.Title = scMensajes[0];
                        sfdExcel.DefaultExt = "XLS";
                        sfdExcel.AddExtension = true;
                        sfdExcel.RestoreDirectory = true;
                        sfdExcel.ShowDialog();
                        RutaExcelConNombreYExtension = sfdExcel.FileName;
                    }
                    //
                    if (!string.IsNullOrEmpty(RutaExcelConNombreYExtension))
                    {
                        //Buscar filtros escojidos en el grid
                        ListaFiltros = new System.Collections.Generic.List<string>();
                        foreach (UltraGridBand b in gridaExportar.DisplayLayout.Bands)
                        {
                            foreach (ColumnFilter cf in b.ColumnFilters)
                            {
                                if (!string.IsNullOrEmpty(cf.ToString()))
                                {
                                    ListaFiltros.Add(string.Format("[{0}] {1}", cf.Column.Header.Caption, cf.ToString()));
                                }
                            }
                        }
                        //
                        if (lFiltros != null)
                        {
                            foreach (var strFiltro in lFiltros)
                            {
                                ListaFiltros.Add(strFiltro);
                            }
                        }
                        //
                        //Exportación
                        if (RutaExcelConNombreYExtension != string.Empty)
                        {
                            Cursor.Current = Cursors.WaitCursor;
                            ugExcelExporter = new Infragistics.Win.UltraWinGrid.ExcelExport.UltraGridExcelExporter();
                            //bookXls = ugExcelExporter.Export(gridaExportar, RutaExcelConNombreYExtension)
                            //Agrego los datos en una columna y fila inicial (depende de los filtros)
                            bookXls = new Infragistics.Documents.Excel.Workbook();
                            bookXls = ugExcelExporter.Export(gridaExportar, bookXls, 0 + ListaFiltros.Count, 1);
                        }
                        //
                        //Agregar una 1a columna que sea el filtro escojido
                        Infragistics.Documents.Excel.Worksheet ActiveSheet = bookXls.Worksheets[0];
                        ActiveSheet.Columns[0].Width = 1000; //Cambiar Ancho primera columna
                        for (int iLin = 0; iLin <= ListaFiltros.Count - 1; iLin++) //Agregar Filtros
                        {
                            Infragistics.Documents.Excel.WorksheetCell oCelda = ActiveSheet.Rows[iLin].Cells[0];
                            oCelda.Value = ListaFiltros[iLin];
                            oCelda.CellFormat.Alignment = Infragistics.Documents.Excel.HorizontalCellAlignment.Left;
                            oCelda.CellFormat.Font.Bold = Infragistics.Documents.Excel.ExcelDefaultableBoolean.True;
                            oCelda.CellFormat.Font.Name = "Arial";
                            oCelda.CellFormat.Font.Height = 165;
                            oCelda.CellFormat.Font.Color = Color.Maroon; // System.Drawing.Color.FromArgb(255, 153, 0, 255)
                        }
                        bookXls.Save(RutaExcelConNombreYExtension);

                        //Abrir el Excel Creado
                        if (bolAbrirDespuesDeCrear)
                        {
                            Process.Start(RutaExcelConNombreYExtension);
                        }
                        if (bolMostrarMensajeFinalizado)
                        {
                            //MsgBox(scMensajes(1), MsgBoxStyle.Information, scMensajes(2)). Prompt, texto, titulo
                            MessageBox.Show(scMensajes[1], scMensajes[2], MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                    }
                    //
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
                finally
                {
                    ListaFiltros = null;
                    if (ugExcelExporter != null)
                    {
                        ugExcelExporter.Dispose();
                    }
                    if (bookXls != null)
                    {
                        bookXls = null;
                    }
                    scMensajes = null;
                    Cursor.Current = Cursors.Default;
                }
            }
            #endregion
            //'
            //*** Si doble click en UltraWinGrid, devuelve Row sobre el que se ha hecho.
            public static UltraGridRow DobleClickEnRowUltraGrid(object objGrid)
            {
                UltraGridRow returnValue;

                //*** Codigo para controlar que doble click se ha hecho sobre un registro
                //Convertir Sender en UltraGrid (parecido a CType)
                UltraGrid grid = (UltraGrid)objGrid;

                //Obtener el ultimoGet the last element that the mouse entered
                Infragistics.Win.UIElement lastElementEntered = grid.DisplayLayout.UIElement.LastElementEntered;

                //See if there's a RowUIElement in the chain.
                RowUIElement rowElement;
                if (lastElementEntered is RowUIElement)
                {
                    rowElement = (RowUIElement)lastElementEntered;
                }
                else
                {
                    rowElement = (RowUIElement)(lastElementEntered.GetAncestor(typeof(RowUIElement)));
                }

                if (rowElement == null)
                {
                    returnValue = null;
                    goto Salir;
                }

                //Try to get a row from the element
                UltraGridRow row = (UltraGridRow)(rowElement.GetContext(typeof(UltraGridRow)));

                //If no row was returned, then the mouse is not over a row.
                if (row == null)
                {
                    returnValue = null;
                    goto Salir;
                }

                //This part is optional, but if the user double-clicks the line between Row
                //selectors, the row is AutoSized by default. In that case, we probably don't
                //want to do the double-click code.

                //Get the current mouse pointer location and convert it to grid coords.
                Point MousePosition = grid.PointToClient(Control.MousePosition);

                //See if the Point is on an AdjustableElement (user is clicking the line on the row selector)
                if (!(lastElementEntered.AdjustableElementFromPoint(MousePosition) == null))
                {
                    returnValue = null;
                    goto Salir;
                }

                //Si llega hasta aqui, devolver Row
                returnValue = row;

            Salir:
                return returnValue;
            }
            //'
            public enum Alineacion
            {
                Derecha,
                Izquierda,
                Centro
            }
            //'
            /// <summary>
            /// Cambiar nombre/ancho columnas, establecer como visible si o no, etc..
            /// </summary>
            /// <param name="gridaTratar"></param>
            /// <param name="TituloAntiguoColumna"></param>
            /// <param name="TituloNuevoColumna"></param>
            /// <param name="Ancho">0 deja el ancho que tiene actualmente</param>
            /// <param name="bolVisible"></param>
            /// <param name="Banda"></param>
            /// <param name="Alineado"></param>
            /// <param name="strOutputFormat">Algún formato para la columna. Por ej: "##,##0.00" (2 decimales mostrando ceros)</param>
            /// <remarks></remarks>
            public static void GridPropiedadesColumnas(UltraGrid gridaTratar, string TituloAntiguoColumna, string TituloNuevoColumna, int Ancho, bool bolVisible, int Banda, Alineacion Alineado, string strOutputFormat)
            {
                UltraGridBand with_1 = gridaTratar.DisplayLayout.Bands[Banda];
                if (bolVisible == false)
                {
                    with_1.Columns[TituloAntiguoColumna].Hidden = true;
                }
                else
                {
                    //Outputformat
                    if (!string.IsNullOrEmpty(strOutputFormat))
                    {
                        with_1.Columns[TituloAntiguoColumna].Format = strOutputFormat;
                    }
                    //Visible
                    with_1.Columns[TituloAntiguoColumna].Hidden = false;
                    //Desactivo editación
                    with_1.Columns[TituloAntiguoColumna].CellActivation = Activation.NoEdit;
                    //Ancho
                    if (Ancho != 0)
                    {
                        with_1.Columns[TituloAntiguoColumna].Width = Ancho;
                    }
                    //Alineación
                    switch (Alineado)
                    {
                        case Alineacion.Izquierda:
                            with_1.Columns[TituloAntiguoColumna].CellAppearance.TextHAlign = Infragistics.Win.HAlign.Left;
                            break;
                        case Alineacion.Centro:
                            with_1.Columns[TituloAntiguoColumna].CellAppearance.TextHAlign = Infragistics.Win.HAlign.Center;
                            break;
                        case Alineacion.Derecha:
                            with_1.Columns[TituloAntiguoColumna].CellAppearance.TextHAlign = Infragistics.Win.HAlign.Right;
                            break;
                    }
                    //Título columna (al final siempre)
                    if (TituloNuevoColumna.Trim() == string.Empty)
                    {
                        TituloNuevoColumna = TituloAntiguoColumna;
                    }
                    with_1.Columns[TituloAntiguoColumna].Header.Caption = TituloNuevoColumna;
                }
            }
            //'
            /// <summary>
            /// Copia al portapapeles de windows la posición de las columnas del grid pasado
            /// en formato código vb.net (Ejemplo: .Columns("Sel").Header.VisiblePosition = 0 )
            /// Consejo: Se puede establecer el orden de las columnas en tiempo de ejecución
            /// y luego ejecutar esto para saber el orden en vb.net y ahorrarnos tiempo
            /// </summary>
            /// <param name="gridOrigen">Grid a tratar</param>
            /// <param name="numLineas">dos lineas de codigo vb.net por línea o una?</param>
            /// <remarks></remarks>
            private static void GenerarCodigoReposicionarColumnas(UltraGrid gridOrigen, int numLineas)
            {
                System.Collections.Generic.SortedDictionary<int, string> cColumnasPosicion;
                string t = string.Empty;
                int x = 1;
                bool bolSaltoLinea = false;


                try
                {
                    //Recorro columnas y ordeno (sino no funciona después)
                    cColumnasPosicion = new System.Collections.Generic.SortedDictionary<int, string>();
                    foreach (UltraGridColumn c in gridOrigen.DisplayLayout.Bands[0].Columns)
                    {
                        cColumnasPosicion.Add(c.Header.VisiblePosition, c.Key);
                    }

                    //Creo texto
                    t = String.Format("With {0}.DisplayLayout.Bands(0){1}", gridOrigen.Name, Environment.NewLine);
                    foreach (int Clave in cColumnasPosicion.Keys)
                    {
                        t += String.Format(".Columns(\"{0}\").Header.VisiblePosition = {1}", cColumnasPosicion[Clave], Clave);
                        bolSaltoLinea = x == numLineas;
                        t += ":";
                        if (bolSaltoLinea)
                        {
                            t += Environment.NewLine;

                            x = 1;
                        }
                        else
                        {
                            x++;
                        }
                    }

                    //Quitar últimos puntos y fin with
                    t = Strings.Left(t, Strings.Len(t) - 3);
                    t += Environment.NewLine + "End With";

                    //Copiar a portapeles
                    TextBox s = new TextBox { Text = t };

                    s.Focus();
                    s.SelectAll();
                    s.Copy();
                    s.Dispose();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, clsVariables.str_NombreAplicacion, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                finally
                {
                    cColumnasPosicion = null;
                }
            }
            //'
            /// <summary>
            /// Agrega suma a la columna especificada
            /// </summary>
            /// <param name="ugObjetivo"></param>
            /// <param name="strKeyColumn"></param>
            /// <param name="TipoCalculo"></param>
            /// <remarks></remarks>
            public static void AgregarQuitarCalculoColumna(UltraGrid ugObjetivo, string strKeyColumn,
                                                                 SummaryType TipoCalculo, bool bolQuitarCalculo = false)
            {
                UltraGridBand ugBand = ugObjetivo.DisplayLayout.Bands[0];
                //.Summaries.Add(Infragistics.Win.UltraWinGrid.SummaryType.Average, Me.ultraGrid1.DisplayLayout.Bands(0).Columns(0))
                //.Summaries.Add(Infragistics.Win.UltraWinGrid.SummaryType.Count, Me.ultraGrid1.DisplayLayout.Bands(0).Columns(1))
                //.Summaries.Add(Infragistics.Win.UltraWinGrid.SummaryType.Maximum, Me.ultraGrid1.DisplayLayout.Bands(0).Columns(2))
                //.Summaries.Add(Infragistics.Win.UltraWinGrid.SummaryType.Minimum, Me.ultraGrid1.DisplayLayout.Bands(0).Columns(3))
                if (!bolQuitarCalculo)
                {
                    if (!ugBand.Summaries.Exists(strKeyColumn))
                    {
                        ugBand.Summaries.Add(strKeyColumn, TipoCalculo, ugBand.Columns[strKeyColumn]);
                        //.SummaryFooterCaption = "Suma Total"
                    }

                }
                else
                {
                    if (ugBand.Summaries.Exists(strKeyColumn))
                    {
                        Infragistics.Win.UltraWinGrid.SummarySettings tmpSettings = ugBand.Summaries[strKeyColumn];
                        ugBand.Summaries.Remove(tmpSettings);
                    }
                }

            }
            //'
            /// <summary>
            /// Cuando el origen de datos es un datatble, ordena las columnas
            /// TODO hacerlo para otros origenes de datos
            /// </summary>
            /// <param name="Grid"></param>
            /// <param name="AnchuraMaximaColumna">0 = no se efectúa este tipo de control</param>
            /// <remarks></remarks>
            public static void AutoAjustarColumnas(UltraGrid Grid, int AnchuraMaximaColumna)
            {
                int TotalFilas = ((System.Data.DataTable)Grid.DataSource).Rows.Count;
                foreach (UltraGridColumn dc in Grid.DisplayLayout.Bands[0].Columns)
                {
                    dc.PerformAutoResize(TotalFilas);
                    if (AnchuraMaximaColumna != 0)
                    {
                        if (dc.Width > AnchuraMaximaColumna)
                        {
                            dc.Width = AnchuraMaximaColumna;
                        }
                    }
                }
            }
            //'
            /// <summary>
            /// Solo necesario para ordenar por Integer las columnas de un Grid de forma 1,2,10,20 y no 1,10,2,20
            /// </summary>
            /// <remarks></remarks>
            public class srtComparer : IComparer
            {

                private string m_ColumnaAOrdenar;

                public srtComparer(string ColumnaAOrdenar)
                {
                    m_ColumnaAOrdenar = ColumnaAOrdenar;
                }

                public int Compare(object x, object y)
                {
                    UltraGridCell xCell = (UltraGridCell)x;
                    UltraGridCell yCell = (UltraGridCell)y;
                    try
                    {
                        //Con decimales. Sino tiene da error
                        return decimal.Compare((decimal)(xCell.Row.Cells[m_ColumnaAOrdenar].Value), (decimal)(yCell.Row.Cells[m_ColumnaAOrdenar].Value));
                    }
                    catch (Exception)
                    {
                        try
                        {
                            //Integers puros
                            return decimal.Compare((decimal)xCell.Row.Cells[m_ColumnaAOrdenar].Value, (decimal)yCell.Row.Cells[m_ColumnaAOrdenar].Value);
                        }
                        catch (Exception ex2)
                        {
                            Console.WriteLine(String.Format("clase <srtComparer>. Campo: {0}. Error: {1}", m_ColumnaAOrdenar, ex2.Message)); //Normalmente pq. el value de 'xCell.Row.Cells(m_ColumnaAOrdenar).Value' vale nothing
                            return 0;
                        }
                    }
                }
            }
            //'             
        }
        //
        public class Ctrl_MDIWindowsListTool
        {
            public static void TraducirTexto()
            {
                Infragistics.Shared.ResourceCustomizer rc = Infragistics.Win.UltraWinToolbars.Resources.Customizer;
                //
                rc.SetCustomizedString("MdiCommandArrangeIcons", "Ordenar Iconos");
                rc.SetCustomizedString("MdiCommandCascade", "Cascada");
                rc.SetCustomizedString("MdiCommandCloseWindows", "Cerrar todas las ventanas");
                rc.SetCustomizedString("MdiCommandTileHorizontal", "Ordenar Horizontalmente");
                rc.SetCustomizedString("MdiCommandTileVertical", "Ordenar Verticalmente");
                rc.SetCustomizedString("MdiCommandMinimizeWindows", "Minimizar todas");
                //rc.SetCustomizedString("MdiCommandArrangeIcons", "Arrange Icons (customized)")
                //rc.SetCustomizedString("MdiCommandCascade", "Cascade (customized)")
                //rc.SetCustomizedString("MdiCommandCloseWindows", "Close All Windows (customized)")
                //rc.SetCustomizedString("MdiCommandTileHorizontal", "Tile Horizontally (customized)")
                //rc.SetCustomizedString("MdiCommandTileVertical", "Tile Vertically (customized)")
                //rc.SetCustomizedString("MdiCommandMinimizeWindows", "Minimize All Windows (customized)")
            }
        }
        //
    }
    //'
    public class Aplicacion
    {
        public static string ObtenerVersionPublicacion()
        {
            string ver = string.Empty;
            if (System.Deployment.Application.ApplicationDeployment.IsNetworkDeployed)
            {
                System.Deployment.Application.ApplicationDeployment ad = System.Deployment.Application.ApplicationDeployment.CurrentDeployment;
                ver = ad.CurrentVersion.ToString();
            }
            return ver;
        }
        //'
        public static string AppConfigRecuperar(string Key, string DefaultValue)
        {
            string ret = DefaultValue; //Valor a retornar, xDefecto (DefaultValue)
            try
            {
                ret = System.Configuration.ConfigurationManager.AppSettings[clsVariables.str_Prefijo + Key].ToString(); //Buscar str_Prefijo + Key
            }
            catch (Exception)
            {
                //-----
                //No Existe la Clave (Si se había indicado str_Prefijo, buscar sin str_Prefijo, sino DefaultValue)
                if (!clsVariables.str_Prefijo.Equals(string.Empty))
                {
                    try
                    {
                        ret = System.Configuration.ConfigurationManager.AppSettings[Key].ToString(); //Buscar Key
                    }
                    catch (Exception ex)
                    {
                        Errores.LanzarError(null, "AppConfigRecuperar", "Key no encontrada: " + Key, ex, MessageBoxIcon.Error);
                    }
                }
            }
            return ret; //Retornar Valor
        }

        public static ArrayList AppConfigRecuperarKeys(string Key, bool BuscarExacto)
        {
            ArrayList Ret = new ArrayList();

            foreach (string KeyApp in System.Configuration.ConfigurationManager.AppSettings.Keys)
            {
                if (BuscarExacto)
                {
                    if (KeyApp == clsVariables.str_Prefijo + Key)
                    {
                        Ret.Add(System.Configuration.ConfigurationManager.AppSettings[KeyApp]);
                    }
                }
                else
                {
                    if (KeyApp.IndexOf(clsVariables.str_Prefijo + Key) + 1 > 0)
                    {
                        Ret.Add(System.Configuration.ConfigurationManager.AppSettings[KeyApp]);
                    }
                }
            }

            return Ret;
        }
        //
        /// <summary>
        /// Sino es frmBase o mtoBase lo abre en MDI
        /// </summary>
        /// <param name="frmFormulario"></param>
        public static void AbrirFormSegunTipoShowForm(ref Form frmFormulario)
        {
            clsVariables.eTipoShowForm intTipoShowForm = clsVariables.eTipoShowForm.Mdi;
            if (frmFormulario is frmBase) { intTipoShowForm = ((frmBase)frmFormulario).TipoShowForm; }
            else if (frmFormulario is mtoBase) { intTipoShowForm = ((mtoBase)frmFormulario).TipoShowForm; }
            //  
            switch (intTipoShowForm)
            {
                case clsVariables.eTipoShowForm.Show: frmFormulario.Show(); break;
                case clsVariables.eTipoShowForm.ShowDialog: frmFormulario.ShowDialog(); break;
                case clsVariables.eTipoShowForm.Mdi: frmFormulario.MdiParent = clsVariables.frm_Principal; frmFormulario.Show(); break;
                default: frmFormulario.Show(); break; //!! Show form lanzado por el Menu
            }
        }
    }
    //'
    public class FicherosCarpetas
    {

        /// <summary>
        /// Devuelve la ruta del fichero escogido
        /// </summary>
        /// <param name="Filtro">Ej: "Ficheros XML (*.xml)|*.xml" o "Office Files|*.doc;*.xls;*.ppt"  o "All Files|*.*"  o "Word Documents|*.doc|Excel Worksheets|*.xls"</param>
        /// <param name="strDirectorioInicial">Carpeta por defecto que mostrará primeramente</param>
        /// <returns></returns>
        /// <remarks></remarks>
        public static string EscogerFichero(string Filtro, string strDirectorioInicial = "")
        {
            try
            {
                using (OpenFileDialog OPDFichero = new OpenFileDialog())
                {
                    OPDFichero.Filter = Filtro;
                    if (!strDirectorioInicial.Trim().Equals(""))
                        OPDFichero.InitialDirectory = strDirectorioInicial;
                    DialogResult File = OPDFichero.ShowDialog();
                    if (File == DialogResult.OK)
                    {
                        return OPDFichero.FileName;
                    }
                    else
                    {
                        return string.Empty;
                    }
                }
            }
            catch (System.Exception ex)
            {
                return string.Empty;
            }
        }
 
        public static void AbrirCarpetaConExplorer(string strRutaCompletaCarpeta)
        {
            if (Directory.Exists(strRutaCompletaCarpeta))
            {

                //System.Diagnostics.Process.Start("explorer.exe", @strRutaCompletaCarpeta);
                string myPath = strRutaCompletaCarpeta;
                System.Diagnostics.Process prc = new System.Diagnostics.Process();
                prc.StartInfo.FileName = myPath;
                prc.Start();
            }
            else
            {
                MessageBox.Show(String.Format("No se puede abrir la ruta: \'{0}\'.", strRutaCompletaCarpeta),
                   clsVariables.str_NombreAplicacion, MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
        //
        public static string StartProcessAndGetResult(string executableFile, string arguments)
        //NOTE executable file should be passed as string with a full path
        //For example: C:\Windows\Microsoft.NET\Framework\v3.0\Windows Communication Foundation\ServiceModelReg.exe
        //Without """ and @ signs
        {
            var result = String.Empty;
            var workingDirectory = System.IO.Path.GetDirectoryName(executableFile);
            var processStartInfo = new ProcessStartInfo(executableFile, arguments)
            {
                WorkingDirectory = workingDirectory,
                UseShellExecute = false,
                ErrorDialog = false,
                CreateNoWindow = true,
                RedirectStandardOutput = true
            };
            var process = Process.Start(processStartInfo);
            if (process != null)
            { using (var streamReader = process.StandardOutput) { result = streamReader.ReadToEnd(); } }
            return result;
        }
    }
    //'
    public class Enums
    {
        public static Boolean EnumFlagContieneValor(Enum ValorEnumFlag, int ValorToSearch)
        {
            //If (userPermission And ePermissions.Read) = ePermissions.Read Then
            //if ((userPermission & ePermissions.Read) == ePermissions.Read) return true;
            int intValorEnumFlag = Convert.ToInt32(ValorEnumFlag);
            return ((ValorToSearch & intValorEnumFlag) == intValorEnumFlag);
        }
    }
    //
    public class General
    {

        public static string ObtenerVersionPublicacion()
        {
            string Ret = "Debug Mode...";
            if (!System.Diagnostics.Debugger.IsAttached)
            {
                try
                {
                    //Ret = My.Application.Deployment.CurrentVersion.ToString
                    Ret = System.Deployment.Application.ApplicationDeployment.CurrentDeployment.CurrentVersion.ToString();
                }
                catch (Exception) { Ret = "No es publicación..."; }
            }
            return Ret;
        }

        //'
        #region                                                                ScpIsNull
        //public static dynamic EstaVacioString(string objStr, string strValorSiEsVacio = "")
        //{
        //   if (string.IsNullOrEmpty(objStr.Trim())) { return strValorSiEsVacio; }
        //   else { return false; }
        //}
        //
        public static bool EstaVacio(object objStr)
        {
            bool returnValue;
            string str;
            if (objStr == System.DBNull.Value || (objStr == null))
            {
                returnValue = true;
            }
            else
            {
                str = objStr.ToString();
                if (str == "")
                {

                    returnValue = true;
                }
                else
                {

                    returnValue = false;
                }
            }
            return returnValue;
        }

        public static object ScpIsNull(object o, object oFalse)
        {
            //Recuperar el Valor predeterminado de devolución
            object oReturn = oFalse;
            //Si no esta VACIO, devolverá el Valor
            if (!(o == DBNull.Value || (o == null) || EstaVacio(o)))
            {
                oReturn = o;
            }
            return oReturn;
        }
        #endregion
        //'
        /// <summary>
        /// Obtener el Nombre del pc
        /// </summary>
        /// <returns></returns>
        /// <remarks></remarks>
        public static string ObtenerGetMachineName()
        {
            string sRet = string.Empty;
            try
            {
                sRet = Environment.MachineName;
            }
            catch (System.Security.SecurityException)
            {

                sRet = "Security Denied";
            }
            catch (Exception)
            {

                sRet = string.Empty;
            }
            return sRet;
        }
        /// <summary>
        /// Recuperar el usuario actual de windows.
        /// </summary>
        /// <returns></returns>
        /// <remarks></remarks>
        public static string ObtenerGetWindowsIdentity()
        {
            string sRet = string.Empty;
            try
            {
                sRet = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            }
            catch (System.Security.SecurityException)
            {

                sRet = "Security Denied";
            }
            catch (Exception)
            {

                sRet = string.Empty;
            }
            return sRet;
        }
    }
    //
    /// <summary>
    /// Simulación de la clase microsoft.visualbasic.strings (q tb podemos importar y usar como esta)
    /// </summary>
    public static class Strings
    {
        #region"Left, Right, Mid"
        /// <summary>
        /// we start at 0 since we want to get the characters starting from the
        /// left and with the specified lenght and assign it to a variable
        /// </summary>
        /// <param name="param"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string Left(string param, int length)
        {
            string result = param.Substring(0, length);
            //return the result of the operation
            return result;
        }
        /// <summary>
        /// start at the index based on the lenght of the sting minus
        /// the specified lenght and assign it a variable
        /// </summary>
        /// <param name="param"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string Right(string param, int length)
        {
            string result = param.Substring(param.Length - length, length);
            //return the result of the operation
            return result;
        }
        /// <summary>
        /// start at the specified index in the string ang get N number of
        /// characters depending on the lenght and assign it to a variable. BAse 1
        /// </summary>
        /// <param name="param"></param>
        /// <param name="startIndex"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string Mid(string param, int startIndex, int length)
        {
            string result;
            if (startIndex != 0) { startIndex -= 1; } //Mid es en base 1 y Substring en base 0
            if (length > Len(param))
            {
                result = param.Substring(startIndex);
            }
            else
            {
                result = param.Substring(startIndex, length + 1);
            }
            //return the result of the operation
            return result;
        }

        /// <summary>
        ///start at the specified index and return all characters after it
        /// and assign it to a variable. Base 1
        /// </summary>
        /// <param name="param"></param>
        /// <param name="startIndex"></param>
        /// <returns></returns>
        public static string Mid(string param, int startIndex)
        {
            string result = param.Substring(startIndex - 1);
            //return the result of the operation
            return result;
        }
        /// <summary>
        /// Devuelve el Len de una cadena
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public static int Len(string param)
        {
            return param.Length;
        }
        #endregion
        //
        public static string ConvertStringArrayToString(string[] array, string strElementoSeparador)
        {
            // Concatenate all the elements into a StringBuilder.
            //StringBuilder builder = new StringBuilder();
            string strbuilder = "";
            foreach (string value in array)
            {
                strbuilder += value + strElementoSeparador;
                //builder.Append(value);
                //builder.Append('.');
            }
            //return builder.ToString();
            return strbuilder.Substring(0, Len(strbuilder) - Len(strElementoSeparador));
        }

    }
}

